﻿using LiteDB;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace LiteDBEntity
{
    public class LiteDbOptions
    {
        public string ConnectionString { get; set; }
        public string CollectionName { get; set; } = "default";
    }


    public class LiteDbRepository<T>: ILiteDbRepository<T> where T : class, new()
    {
        private readonly LiteDatabase _database;
        private readonly LiteDbOptions _options;
        private readonly ILiteCollection<T> _collection;

        public LiteDbRepository(LiteDbOptions options, string collectionName = null)
        {
            _options = options;
           _database = new LiteDatabase(_options.ConnectionString);
            collectionName ??= typeof(T).Name;
            _collection = _database.GetCollection<T>(collectionName);
        }

        // 插入单个文档
        public void Insert(T document)
        {
            _collection.Insert(document);
        }

        // 插入多个文档
        public void Insert(IEnumerable<T> documents)
        {
            _collection.InsertBulk(documents);
        }

        // 更新文档
        public bool Update(T document)
        {
            return _collection.Update(document);
        }

        // 删除文档
        public bool Delete(BsonValue id)
        {
            return _collection.Delete(id);
        }

        // 使用 Lambda 表达式查询单个文档
        public T FindOne(Expression<Func<T, bool>> predicate)
        {
            return _collection.FindOne(predicate);
        }

        // 使用 Lambda 表达式查询多个文档
        public IEnumerable<T> Find(Expression<Func<T, bool>> predicate)
        {
            return _collection.Find(predicate);
        }

        // 查询所有文档
        public IEnumerable<T> FindAll()
        {
            return _collection.FindAll();
        }

        // 查询所有文档 分页
        public IEnumerable<T> FindAll(int index, int size, Expression<Func<T, bool>> predicate)
        {
            return _collection.Query().Where(predicate).Skip(index - 1).Limit(size).ToEnumerable();
        }

        // 使用 Lambda 表达式查询并返回第一个结果
        public T FirstOrDefault(Expression<Func<T, bool>> predicate)
        {
            return _collection.FindOne(predicate);
        }

        // 使用 Lambda 表达式判断是否存在符合条件的文档
        public bool Exists(Expression<Func<T, bool>> predicate)
        {
            return _collection.Exists(predicate);
        }

        // 确保索引存在
        public void EnsureIndex<K>(Expression<Func<T, K>> property, bool unique = false)
        {
            _collection.EnsureIndex(property, unique);
        }

        // 获取集合中文档数量
        public int Count()
        {
            return _collection.Count();
        }

        // 使用条件获取文档数量
        public int Count(Expression<Func<T, bool>> predicate)
        {
            return _collection.Count(predicate);
        }

        // 实现 IDisposable
        public void Dispose()
        {
            _database?.Dispose();
        }
    }
}
